home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / SECDR13A.ZIP / SDCOMMON.C < prev    next >
C/C++ Source or Header  |  1994-01-29  |  11KB  |  378 lines
  1. /* Secure Drive V1.3A */
  2. /* Code common to CRYPTDSK and LOGIN */
  3.  
  4. #include "secdrv.h"
  5.  
  6. struct tsrdata far *cryptdata;
  7.  
  8. char pass1[MAXPASS];
  9. char pass2[MAXPASS];
  10. char Old13Check[4];
  11.  
  12. int  tsr_not_installed=0;
  13. int  tsr_wrong_version=0;
  14. int  df10=1,ef10=1;
  15.  
  16.  
  17. char compat_mode='N';
  18.  
  19.  
  20. void setrldb(void far *real_dbios_vect);
  21.  
  22. void set_compat_mode(void)
  23. {
  24.  char *p;
  25.  if ((p=getenv("SD10CMP")) != NULL)
  26.  compat_mode = toupper(p[0]);
  27.  if ( compat_mode == 'Y' || compat_mode == 'X')
  28.   {
  29.    printf("\nVersion 1.0 %s Compatibility is Active\n",
  30.     compat_mode == 'X' ? "eXclusive" : "Normal");
  31.   }
  32.  else compat_mode='N';
  33. }
  34.  
  35. void invgets(char *input)
  36. {
  37. unsigned i=0;
  38. char c;
  39. while(i<(MAXPASS-1)) {
  40.     c=getch();
  41.     if(c=='\x0d')
  42.         {
  43.         printf("\n");
  44.         *input='\0';
  45.         return;
  46.         }
  47.     else if(c=='\b')
  48.         {
  49.         if(i>0)
  50.             {
  51.             i--;
  52.             input--;
  53.             printf("\b \b");
  54.             }
  55.         }
  56.     else
  57.         {
  58.         printf("*");
  59.         *input++=c;
  60.         i++;
  61.         }
  62.     }
  63. }
  64.  
  65. void readsec(unsigned drive,unsigned head,unsigned track,
  66.              unsigned sector,unsigned nsects,void *buffer)
  67. {
  68. unsigned i;
  69. char c;
  70. for(;;) {
  71.     for(i=0;i<3;i++)
  72.         if(!rldbios(2,drive,head,track,sector,nsects,buffer)) return;
  73.     printf("\nRead error: drive %02x, head %u, track %u\n",
  74.             drive,head,track);
  75.     printf("Abort, Retry, Ignore? ");
  76.     c=toupper(getch()); printf("%c\n",c);
  77.     if(c=='I') return;
  78.     if(c=='A') exit(1);
  79.     }
  80. }
  81.  
  82. void writesec(unsigned drive,unsigned head,unsigned track,
  83.               unsigned sector,unsigned nsects,void *buffer)
  84. {
  85. unsigned i;
  86. char c;
  87. unsigned r;
  88. for(;;) {
  89.     for(i=0;i<3;i++)
  90.      {
  91.         r=rldbios(3,drive,head,track,sector,nsects,buffer);
  92.         if(!r) return;
  93.      }
  94.     if (r == 03 && drive<0x80)
  95.      {
  96.       printf("\nERROR: Disk %c is Write-Protected!\n",drive+'A');
  97.      }
  98.     else
  99.      printf("\nWrite error: drive %02x, head %u, track %u\n",
  100.             drive,head,track);
  101.     printf("Abort, Retry, Ignore? ");
  102.     c=toupper(getch()); printf("%c\n",c);
  103.     if(c=='I') return;
  104.     if(c=='A') exit(1);
  105.     }
  106. }
  107.  
  108. int getyn(void)
  109. {
  110. char c;
  111. for(;;)
  112.     {
  113.     c=getch();
  114.     if(c=='y'||c=='Y') { printf("Yes\n\n"); return(TRUE); }
  115.     if(c=='n'||c=='N') { printf("No\n\n"); return(FALSE); }
  116.     }
  117. }
  118.  
  119. void getkeydf(unsigned char *key,unsigned char *check,unsigned char *bufck)
  120. {
  121. unsigned char temp[16];
  122. MD5_CTX md5buf;
  123. unsigned k;
  124.  
  125. invgets(pass1);
  126. setkeydf(key,check,bufck);
  127. }
  128.  
  129. void getkey(unsigned char *key,unsigned char *check,int confirm)
  130. {
  131. unsigned char temp[16];
  132. MD5_CTX md5buf;
  133. unsigned k;
  134.  
  135. if(confirm) printf("\
  136. You need a passphrase to encrypt this disk. Your passphrase should be\n\
  137. fairly long, and should not appear verbatim in any literature or text.\n\
  138. Passphrases are case sensitive - this can be a security feature or it\n\
  139. can be a hazard. If you lose or forget your passphrase, there is no way\n\
  140. to recover the encrypted data!\n");
  141. enterpass:
  142. if(confirm) printf("\nEnter passphrase: ");
  143. invgets(pass1);
  144. if(confirm) {
  145.    int good=TRUE;
  146.    int upper=FALSE;
  147.    int lower=FALSE;
  148.    int other=FALSE;
  149.    unsigned i,j;
  150.    char c;
  151.    printf("\n");
  152.    i=strlen(pass1);
  153.    if(i<8) {
  154.        printf("Your passphrase is only %i characters long.\n",i);
  155.        good=FALSE; }
  156.    for(j=0;j<i;j++) {
  157.        c=pass1[j];
  158.        if(isupper(c)) upper=TRUE;
  159.        else if (islower(c)) lower=TRUE;
  160.        else if (!isspace(c)) other=TRUE; }
  161.    if(upper&&!lower&&!other) {
  162.        printf("Your passphrase is monocase (uppercase only).\n");
  163.        good=FALSE; }
  164.    if(lower&&!upper&&!other) {
  165.        printf("Your passphrase is monocase (lowercase only).\n");
  166.        good=FALSE; }
  167.    if(i>15) good=TRUE;
  168.    if(!good) printf("\nThis passphrase may not be secure.\
  169.  If you want to use it, retype it to\nconfirm. If not, press return to\
  170.  try again.\n\n");
  171.    printf("Re-enter passphrase: ");
  172.    invgets(pass2);
  173.    printf("\n");
  174.    if(strcmp(pass1,pass2)) {
  175.        printf("Passphrases do not match. Try again.\n");
  176.        goto enterpass; }
  177.    }
  178. setkeye(key,check);
  179. }
  180.  
  181. void setkeye (unsigned char *key, unsigned char *check)
  182. {
  183.   ef10=(compat_mode != 'N');
  184.   if (ef10)
  185.    setkey10(key,check);
  186.   else
  187.    setkey13(key,check);
  188. }
  189.  
  190.  
  191. void setkeydf(unsigned char *key,unsigned char *check,unsigned char *bufck)
  192. {
  193.  memset(Old13Check,0xff,4);
  194.  setkey10(key,check);
  195.  if(memcmp(check,bufck,4) == 0)
  196.   {
  197.    df10=1;
  198.    return;
  199.   }
  200.  df10=0;
  201.  if (compat_mode == 'X')
  202.   return;
  203.  setkey13(key,check);
  204. }
  205.  
  206. void setkey10(unsigned char *key,unsigned char *check)
  207.  {
  208.   unsigned char temp[16];
  209.   MD5_CTX md5buf;
  210.  
  211.   MD5Init(&md5buf);
  212.   MD5Update(&md5buf,pass1,strlen(pass1));
  213.   MD5Final(key,&md5buf);
  214.  
  215.   MD5Init(&md5buf);
  216.   MD5Update(&md5buf,key,16);
  217.   MD5Final(temp,&md5buf);
  218.   memcpy(check,temp,4);
  219.  }
  220.  
  221. void setkey13(unsigned char *key,unsigned char *check)
  222.  {
  223.   unsigned char temp[16];
  224.   int k;
  225.   MD5_CTX md5buf;
  226.   MD5_CTX md5sav;
  227.  
  228.   MD5Init(&md5buf);
  229.   MD5Update(&md5buf,pass1,strlen(pass1));
  230.   MD5Final(key,&md5buf);
  231.  
  232.   for(k=0;k<PASS_ITER;k++)
  233.    {
  234.     MD5Init(&md5buf);
  235.     MD5Update(&md5buf,key,16);
  236.     MD5Update(&md5buf,pass1,strlen(pass1));
  237.     MD5Final(key,&md5buf);
  238.    }
  239.  
  240.   MD5Init(&md5buf);
  241.   MD5Update(&md5buf,key,16);
  242.   memcpy((void *)&md5sav,(void *)&md5buf,sizeof(md5buf));
  243.   MD5Update(&md5buf,pass1,strlen(pass1));
  244.   MD5Final(temp,&md5buf);
  245.   memcpy(check,temp,4);               /*1.1/1.3A  Check*/
  246.   memcpy((void *)&md5buf,(void *)&md5sav,sizeof(md5buf));
  247.   MD5Final(temp,&md5buf);             /*1.3 Check*/
  248.   memcpy(Old13Check,temp,4);
  249.  }
  250.  
  251. struct tsrdata far *gettsradr(void)
  252. {
  253. unsigned seg;
  254. unsigned ofs;
  255. struct tsrdata far *ptr;
  256. struct REGPACK rgs;
  257.  
  258. rgs.r_ax=0x0800;
  259. rgs.r_dx=0x00f0;
  260. intr(0x13,&rgs);
  261. if(rgs.r_ax==0x0edcb)
  262.  {
  263.   tsr_wrong_version=1;
  264.   return( (struct tsrdata far *) NULL);
  265.  }
  266. if(rgs.r_ax!=0x0edcc)
  267.  {
  268.   tsr_not_installed=1;
  269.   return( (struct tsrdata far *) NULL);
  270.  }
  271. /* ptr=(long) rgs.r_dx+(long) 0x10000*rgs.r_cx; */
  272. ptr = MK_FP(rgs.r_cx,rgs.r_dx);
  273. if (memcmp(ptr->tsrver,"130A",4) != 0)
  274.  {
  275.   tsr_wrong_version=1;
  276.   return( (struct tsrdata far *) NULL);
  277.  }
  278. setrldb(&ptr->real_dbios_vect);
  279. return(ptr);
  280. }
  281.  
  282. void readptbl(unsigned char drvltr,unsigned *ptdrive,         /*1.1*/
  283.               unsigned *pthead,unsigned *pttrack)             /*1.1*/
  284. {                                                             /*1.1*/
  285. unsigned char buf[512];                                       /*1.1*/
  286. *ptdrive=255;                                                 /*1.1*/
  287. rdptx(0,0,0,&drvltr,ptdrive,pthead,pttrack,FALSE,buf);        /*1.1*/
  288. if(*ptdrive!=255) return;                                     /*1.1*/
  289. else rdptx(1,0,0,&drvltr,ptdrive,pthead,pttrack,FALSE,buf);   /*1.1*/
  290. if(*ptdrive!=255) return;                                     /*1.1*/
  291. else {                                                        /*1.1*/
  292.     drvltr++;                                                 /*1.1*/
  293.     rdptx(0,0,0,&drvltr,ptdrive,pthead,pttrack,TRUE,buf);     /*1.1*/
  294.      }                                                        /*1.1*/
  295. if(*ptdrive!=255) return;                                     /*1.1*/
  296. else {                                                        /*1.1*/
  297.     drvltr++;                                                 /*1.1*/
  298.     rdptx(1,0,0,&drvltr,ptdrive,pthead,pttrack,TRUE,buf);     /*1.1*/
  299.      }                                                        /*1.1*/
  300. }                                                             /*1.1*/
  301.  
  302. void rdptx(unsigned drive,unsigned head,unsigned track,       /*1.1*/
  303.            unsigned char *letter, unsigned *ptdrive,          /*1.1*/
  304.            unsigned *pthead,unsigned *pttrack,int recurse,    /*1.1*/
  305.            unsigned char *buf)                                /*1.1*/
  306. {                                                             /*1.1*/
  307. unsigned i,pt,ph,pc;                                          /*1.1*/
  308. unsigned char *bufp;                                          /*1.1*/
  309. if(rldbios(2,drive+0x80,head,track,1,1,buf)) return;          /*1.1*/
  310. for(i=0;i<4;i++) {                                            /*1.1*/
  311.     bufp=buf+0x1be+(i*16);                                    /*1.1*/
  312.     pt=bufp[4];                                               /*1.1*/
  313.     ph=bufp[1];                                               /*1.1*/
  314.     pc=bufp[3]+(bufp[2]>>6)*256;                              /*1.1*/
  315.     if((pt==1)||(pt==4)||(pt==6)) {                           /*1.1*/
  316.         if(*letter=='C') {                                    /*1.1*/
  317.             *ptdrive=drive;                                   /*1.1*/
  318.             *pthead=ph;                                       /*1.1*/
  319.             *pttrack=pc;                                      /*1.1*/
  320.             return; }                                         /*1.1*/
  321.         else {                                                /*1.1*/
  322.            (*letter)--;                                       /*1.1*/
  323.            if(!recurse) return; } }                           /*1.1*/
  324.     else if(pt==5) rdptx(drive,ph,pc,letter,ptdrive,          /*1.1*/
  325.                          pthead,pttrack,TRUE,buf); }          /*1.1*/
  326. }                                                             /*1.1*/
  327.  
  328. /*      Compute IDEA encryption subkeys Z */
  329. void en_key_idea(word16 *userkey, word16 *Z)
  330. {
  331.         unsigned i,j;
  332.         word16 *Y=Z;
  333.         /*
  334.          * shifts
  335.          */
  336.         for (j=0; j<8; j++)
  337.                 Z[j] = *userkey++;
  338.  
  339.         for (i=0; j<KEYLEN; j++)
  340.         {       i++;
  341.                 Z[i+7] = Z[i & 7] << 9 | Z[i+1 & 7] >> 7;
  342.                 Z += i & 8;
  343.                 i &= 7;
  344.         }
  345.         for(i=0;i<52;i++)
  346.                 Y[i]^=0x0dae;
  347. }        /* en_key_idea */
  348.  
  349. void calcdiskparams(unsigned char *buf,unsigned *maxtrack,
  350.                     unsigned *maxhead,unsigned *maxsector,
  351.                     unsigned *secsize,unsigned serial[2])
  352. {
  353. unsigned long i,l0,l1,l2,l3;
  354. *maxsector=buf[0x18]+256*buf[0x19];
  355. *maxhead=buf[0x1a]+256*buf[0x1b];
  356. *secsize=buf[0x0b]+256*buf[0x0c];
  357. serial[0]=buf[0x27]+256*buf[0x28];
  358. serial[1]=buf[0x29]+256*buf[0x2a];
  359. l0=(unsigned char)buf[0x20];
  360. l1=(unsigned char)buf[0x21];
  361. l2=(unsigned char)buf[0x22];
  362. l3=(unsigned char)buf[0x23];
  363. i=l0+256*(l1+256*(l2+256*(l3)));
  364. if(i==0) i=(unsigned)buf[0x13]+256*buf[0x14];
  365. *maxtrack=i / *maxsector / *maxhead;
  366. if((i%(*maxsector * *maxhead))==0) (*maxtrack)--;
  367. }
  368.  
  369. void clrbufs(void)
  370.  {
  371.   int k;
  372.   for(k=0;k<MAXPASS;k++)
  373.   {
  374.     pass1[k]='\0';
  375.     pass2[k]='\0';
  376.   }
  377.  }
  378.